"""
用户信息数据库操作类
"""

from typing import List, Dict, Any, Literal
from db.operations import BaseOperations


class UserOperations(BaseOperations):
    """用户信息数据库操作类"""

    def __init__(self):
        # 继承BaseOperations，指定表名为users
        super().__init__("users")

    async def batch_insert_users(self, users_data: List[Dict[str, Any]]) -> int:
        """
        批量插入用户数据

        Args:
            users_data (List[Dict[str, Any]]): 用户数据列表
            每个字典应包含用户的字段，例如：
            {
                "username": "用户名",
                "password": "加密后的密码"
            }
            on_duplicate (str): 重复处理策略 - "skip"(跳过), "update"(更新)

        Returns:
            int: 成功插入的用户数量
        """
        if not users_data:
            return 0

        # 调用父类的批量插入方法
        return await self.batch_insert(users_data, on_duplicate="skip")

    async def batch_query_users(
        self,
        user_ids: List[int] = None,
        usernames: List[str] = None,
        order_by: str = "user_id ASC",
    ) -> List[Dict[str, Any]]:
        """
        批量查询用户的所有数据

        Args:
            user_ids (List[int], optional): 用户ID列表
            usernames (List[str], optional): 用户名列表
            order_by (str): 排序子句，默认按 user_id 升序排列

        Returns:
            List[Dict[str, Any]]: 查询到的用户信息列表
        """
        where_conditions = []
        params = []

        # 根据用户ID查询
        if user_ids:
            placeholders = ", ".join(["%s"] * len(user_ids))
            where_conditions.append(f"user_id IN ({placeholders})")
            params.extend(user_ids)

        # 根据用户名查询
        if usernames:
            placeholders = ", ".join(["%s"] * len(usernames))
            where_conditions.append(f"username IN ({placeholders})")
            params.extend(usernames)

        # 构建WHERE子句
        where_clause = ""
        if where_conditions:
            where_clause = " AND ".join(where_conditions)  # 调用父类的批量查询方法
        return await self.batch_query(
            where_clause=where_clause,
            params=tuple(params) if params else None,
            order_by=order_by,
        )

    async def batch_update_users(
        self,
        update_datas: List[Dict[str, Any]],
    ) -> int:
        """
        批量更新用户数据

        Args:
            update_datas (List[Dict[str, Any]]): 更新数据列表
            每个字典应包含用户标识字段和要更新的字段，例如：
            {
                "user_id": 1,  # 用户ID（必须）
                "nickname": "新昵称",
                "age": 26,
                "gender": "女"
                "password": "新加密密码",
                "updated_at": 1700000000  # 更新时间戳
            }

        Returns:
            int: 成功更新的用户数量
        """
        if not update_datas:
            return 0

        # 验证数据格式
        for update_data in update_datas:
            if "user_id" not in update_data:
                print("警告：更新数据中缺少 user_id，跳过该条记录")
                return 0

        # 调用父类的批量更新方法，指定主键为user_id
        return await self.batch_update(update_datas, primary_key="user_id")

    async def delete_user(self, user_id: int) -> bool:
        """
        删除用户及其所有相关数据

        由于数据库表结构中设置了外键约束 ON DELETE CASCADE，
        删除用户时会自动删除所有数据
        Args:
            user_id (int): 要删除的用户ID

        Returns:
            bool: 删除成功返回True，失败返回False
        """
        try:
            pool = await self.db_connection.get_pool()
            async with pool.acquire() as conn:
                async with conn.cursor() as cursor:
                    # 删除用户记录，外键约束会自动删除相关数据
                    sql = "DELETE FROM users WHERE user_id = %s"
                    affected_rows = await cursor.execute(sql, (user_id,))

                    if affected_rows > 0:
                        print(f"用户 {user_id} 及其所有相关数据已成功删除")
                        return True
                    else:
                        print(f"用户 {user_id} 不存在或删除失败")
                        return False

        except Exception as e:
            print(f"删除用户 {user_id} 时发生错误: {e}")
            return False
